/*
 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/*
 * @(#)DBMetaClient10.java	1.23 02/01/12
 */

package jdbcts.dbMeta.dbMeta10;

import java.io.*;
import java.util.*;

import java.sql.*;
import javax.sql.*;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.sun.cts.util.*;
import com.sun.cts.porting.*;
import com.sun.cts.harness.*;

import java.rmi.RemoteException;

import javasoft.sqe.javatest.Status;
import jdbcts.SuperTest;
import jdbcts.common.DataSourceConnection;
import jdbcts.common.DriverManagerConnection;
import jdbcts.common.dbSchema;

import com.sun.cts.tests.jdbc.ee.common.*;

// Merant DataSource class
//import com.merant.sequelink.jdbcx.datasource.*;

/**
 * The dbMetaClient class tests methods of DatabaseMetaData interface using
 * Sun's J2EE Reference Implementation.
 * 
 * @author
 * @version 1.7, 06/16/99
 */

public class DBMetaClient10 extends SuperTest implements Serializable
{
    private static final String testName = "jdbc.ee.dbMeta.dbMeta10";

    // Naming specific member variables
    private CTSNamingContextInterface jc = null;

    // Harness requirements

    private transient static Connection conn = null;

    private transient static DatabaseMetaData dbmd = null;

    private DataSource ds1 = null;

    private static dbSchema dbSch = null;

//    private String dbName = null, dbUser = null, drManager = null;
    private static String drManager = null;

//    private String sCatalogName = null, sSchemaName = null, sPtable = null,
//	    sFtable = null;

    /* Run test in standalone mode */
//    public static void main(String[] args)
//    {
//	DBMetaClient10 theTests = new DBMetaClient10();
//	Status s = theTests.run(args, System.out, System.err);
//	s.exit();
//    }

    /* Test setup: */
    /*
     * @class.setup_props: Driver, the Driver name; db1, the database name with
     * url; user1, the database user name; password1, the database password;
     * db2, the database name with url; user2, the database user name;
     * password2, the database password; DriverManager, flag for DriverManager;
     * ptable, the primary table; ftable, the foreign table; cofSize, the
     * initial size of the ptable; cofTypeSize, the initial size of the ftable;
     * binarySize, size of binary data type; varbinarySize, size of varbinary
     * data type; longvarbinarySize, size of longvarbinary data type;
     * 
     * @class.testArgs: -ap ctssql.stmt
     */
    @BeforeClass
//    public void setup(String[] args, Properties p) throws Exception
    public static void setup() throws Exception
    {
	try
	{
	    try
	    {
//		drManager = p.getProperty("DriverManager", "");
		drManager = isDRManager;
//		dbName = p.getProperty("db1", "");
//		dbUser = p.getProperty("user1", "");
//		sPtable = p.getProperty("ptable", "CTSTABLE1");
//		sFtable = p.getProperty("ftable", "CTSTABLE2");
//		if (dbName.length() == 0)
//		    throw new Exception("Invalid db1  Database Name");
//		if (dbUser.length() == 0)
//		    throw new Exception("Invalid Login Id");
//		if (sPtable.length() == 0)
//		    throw new Exception("Invalid Primary table");
//		if (sFtable.length() == 0)
//		    throw new Exception("Invalid Foreign table");
		if (drManager.length() == 0)
		    throw new Exception("Invalid DriverManager Name");

//		int nLocdbname = dbName.indexOf('=');
//		sSchemaName = dbUser;

		if (drManager.equals("yes"))
		{
		    logMsg("Using DriverManager");
		    DriverManagerConnection dmCon = new DriverManagerConnection();
//		    conn = dmCon.getConnection(p);
		    conn = dmCon.getConnection(null);
		}
		else
		{
		    logMsg("Using DataSource");
		    DataSourceConnection dsCon = new DataSourceConnection();
//		    conn = dsCon.getConnection(p);
		    conn = dsCon.getConnection(null);
		}
		dbSch = new dbSchema();
//		dbSch.createData(p, conn);
		dbmd = conn.getMetaData();
	    }
	    catch (SQLException ex)
	    {
		logErr("SQL Exception : " + ex.getMessage());
	    }
	}
	catch (Exception e)
	{
	    logErr("Setup Failed!");
	    TestUtil.printStackTrace(e);
	}
    }

    /*
     * @testName: testOthersUpdatesAreVisible2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersUpdatesAreVisible(int resType) method must return a boolean value;
     * true if a rows updated by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherUpdatesAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersUpdatesAreVisible2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersUpdatesAreVisible(TYPE_SCROLL_INSENSITIVE)");
	    // invoke othersUpdatesAreVisible method
	    boolean retValue = dbmd
		    .othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Updates made by others are visible for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Updates made by others are not visible for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersUpdatesAreVisible2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersUpdatesAreVisible2 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersUpdatesAreVisible3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersUpdatesAreVisible(int resType) method must return a boolean value;
     * true if a rows updated by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherUpdatesAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_SENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersUpdatesAreVisible3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersUpdatesAreVisible(TYPE_SCROLL_SENSITIVE)");
	    // invoke othersUpdatesAreVisible method
	    boolean retValue = dbmd
		    .othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Updates made by others are visible for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Updates made by others are not visible for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersUpdatesAreVisible3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersUpdatesAreVisible3 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersDeletesAreVisible1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersDeletesAreVisible(int resType) method must return a boolean value;
     * true if a rows deleted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherDeletesAreVisible(int resType) method on that
     * object with ResultSet.TYPE_FORWARD_ONLY. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersDeletesAreVisible1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_FORWARD_ONLY)");
	    // invoke othersDeletesAreVisible method
	    boolean retValue = dbmd
		    .othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY);
	    if (retValue)
		logMsg("Deletes made by others are visible for TYPE_FORWARD_ONLY");
	    else
		logMsg("Deletes made by others are not visible for TYPE_FORWARD_ONLY");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible1 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible1 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersDeletesAreVisible2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersDeletesAreVisible(int resType) method must return a boolean value;
     * true if a rows deleted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherDeletesAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersDeletesAreVisible2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_SCROLL_INSENSITIVE)");
	    // invoke othersDeletesAreVisible method
	    boolean retValue = dbmd
		    .othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Deletes made by others are visible for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Deletes made by others are not visible for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible2 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersDeletesAreVisible3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersDeletesAreVisible(int resType) method must return a boolean value;
     * true if a rows deleted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherDeletesAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_SENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersDeletesAreVisible3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_SCROLL_SENSITIVE)");
	    // invoke othersDeletesAreVisible method
	    boolean retValue = dbmd
		    .othersDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Deletes made by others are visible for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Deletes made by others are not visible for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersDeletesAreVisible3 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersInsertsAreVisible1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersInsertsAreVisible(int resType) method must return a boolean value;
     * true if a rows inserted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherInsertsAreVisible(int resType) method on that
     * object with ResultSet.TYPE_FORWARD_ONLY. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersInsertsAreVisible1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_FORWARD_ONLY)");
	    // invoke othersInsertsAreVisible method
	    boolean retValue = dbmd
		    .othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY);
	    if (retValue)
		logMsg("Inserts made by others are visible for TYPE_FORWARD_ONLY");
	    else
		logMsg("Inserts made by others are not visible for TYPE_FORWARD_ONLY");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible1 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible1 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersInsertsAreVisible2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersInsertsAreVisible(int resType) method must return a boolean value;
     * true if a rows inserted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherInsertsAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersInsertsAreVisible2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_SCROLL_INSENSITIVE)");
	    // invoke othersInsertsAreVisible method
	    boolean retValue = dbmd
		    .othersInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Inserts made by others are visible for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Inserts made by others are not visible for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible2 is Failed!", e);
	}
    }

    /*
     * @testName: testOthersInsertsAreVisible3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * othersInsertsAreVisible(int resType) method must return a boolean value;
     * true if a rows inserted by others are visible and false otherwise. The
     * possible values for resType are TYPE_FORWARD_ONLY,
     * TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE. (See JDK 1.2.2 API
     * documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the otherInsertsAreVisible(int resType) method on that
     * object with ResultSet.TYPE_SCROLL_SENSITIVE. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testOthersInsertsAreVisible3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_SCROLL_SENSITIVE)");
	    // invoke othersInsertsAreVisible method
	    boolean retValue = dbmd
		    .othersInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Inserts made by others are visible for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Inserts made by others are not visible for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to othersInsertsAreVisible3 is Failed!", e);
	}
    }

    /*
     * @testName: testUpdatesAreDetected1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The updatesAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowUpdated returns true when called on a ResultSet object with
     * a given type that contains visible row updates; false if the method
     * ResultSet.rowUpdated returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the updatesAreDetected() method on that object with the
     * ResultSet Type as ResultSet.TYPE_FORWARD_ONLY. It should return a boolean
     * value; either true or false.
     */
    @Test
    public void testUpdatesAreDetected1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.updatesAreDetected(TYPE_FORWARD_ONLY)");
	    // invoke updatesAreDetected method
	    boolean retValue = dbmd
		    .updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY);
	    if (retValue)
		logMsg("Visible row update can be detected for TYPE_FORWARD_ONLY");
	    else
		logMsg("Visible row update cannot be detected for TYPE_FORWARD_ONLY");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to updatesAreDetected1 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to updatesAreDetected1 is Failed!", e);
	}
    }

    /*
     * @testName: testUpdatesAreDetected2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The updatesAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowUpdated returns true when called on a ResultSet object with
     * a given type that contains visible row updates; false if the method
     * ResultSet.rowUpdated returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the updatesAreDetected() method on that object with the
     * ResultSet Type as ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a
     * boolean value; either true or false.
     */
    @Test
    public void testUpdatesAreDetected2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.updatesAreDetected(TYPE_SCROLL_INSENSITIVE)");
	    // invoke updatesAreDetected method
	    boolean retValue = dbmd
		    .updatesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Visible row update can be detected for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Visible row update cannot be detected for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to updatesAreDetected2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to updatesAreDetected2 is Failed!", e);
	}
    }

    /*
     * @testName: testUpdatesAreDetected3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The updatesAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowUpdated returns true when called on a ResultSet object with
     * a given type that contains visible row updates; false if the method
     * ResultSet.rowUpdated returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the updatesAreDetected() method on that object with the
     * ResultSet Type as ResultSet.TYPE_SCROLL_SENSITIVE. It should return a
     * boolean value; either true or false.
     */
    @Test
    public void testUpdatesAreDetected3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.updatesAreDetected(TYPE_SCROLL_SENSITIVE)");
	    // invoke updatesAreDetected method
	    boolean retValue = dbmd
		    .updatesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Visible row update can be detected for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Visible row update cannot be detected for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to updatesAreDetected3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to updatesAreDetected3 is Failed!", e);
	}
    }

    /*
     * @testName: testDeletesAreDetected1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The deletesAreDetected(int
     * resType) method must return a boolean value; true if changes are detected
     * by the resultset type and false otherwise. The possible values for
     * resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
     * TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the deletesAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_FORWARD_ONLY. It should return a
     * boolean value; either true or false.
     */
    @Test
    public void testDeletesAreDetected1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.deletesAreDetected(TYPE_FORWARD_ONLY)");
	    // invoke deletesAreDetected method
	    boolean retValue = dbmd
		    .deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY);
	    if (retValue)
		logMsg("Visible row delete can be detected for TYPE_FORWARD_ONLY");
	    else
		logMsg("Visible row delete cannot be detected for TYPE_FORWARD_ONLY");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to deletesAreDetected1 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to deletesAreDetected1 is Failed!", e);
	}
    }

    /*
     * @testName: testDeletesAreDetected2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The deletesAreDetected(int
     * resType) method must return a boolean value; true if changes are detected
     * by the resultset type and false otherwise. The possible values for
     * resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
     * TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the deletesAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a
     * boolean value; either true or false.
     */
    @Test
    public void testDeletesAreDetected2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.deletesAreDetected(TYPE_SCROLL_INSENSITIVE)");
	    // invoke deletesAreDetected method
	    boolean retValue = dbmd
		    .deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Visible row delete can be detected for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Visible row delete cannot be detected for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to deletesAreDetected2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to deletesAreDetected2 is Failed!", e);
	}
    }

    /*
     * @testName: testDeletesAreDetected3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The deletesAreDetected(int
     * resType) method must return a boolean value; true if changes are detected
     * by the resultset type and false otherwise. The possible values for
     * resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
     * TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the deletesAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_SCROLL_SENSITIVE. It should return a
     * boolean value; either true or false.
     */
    @Test
    public void testDeletesAreDetected3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.deletesAreDetected(TYPE_SCROLL_SENSITIVE)");
	    // invoke deletesAreDetected method
	    boolean retValue = dbmd
		    .deletesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Visible row delete can be detected for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Visible row delete cannot be detected for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to deletesAreDetected3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to deletesAreDetected3 Failed!", e);
	}
    }

    /*
     * @testName: testInsertsAreDetected1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The insertsAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowInserted returns true when called on a ResultSet object with
     * a given type that contains visible row insertion; false if the method
     * ResultSet.rowInserted returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the insertsAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_FORWARD_ONLY. It should return a
     * boolean value; either or false.
     */
    @Test
    public void testInsertsAreDetected1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.insertsAreDetected(TYPE_FORWARD_ONLY)");
	    // invoke insertsAreDetected method
	    boolean retValue = dbmd
		    .insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY);
	    if (retValue)
		logMsg("Visible row insert can be detected for TYPE_FORWARD_ONLY");
	    else
		logMsg("Visible row insert cannot be detected for TYPE_FORWARD_ONLY");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to insertsAreDetected1 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to insertsAreDetected1 is Failed!", e);
	}
    }

    /*
     * @testName: testInsertsAreDetected2
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The insertsAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowInserted returns true when called on a ResultSet object with
     * a given type that contains visible row insertion; false if the method
     * ResultSet.rowInserted returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the insertsAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_SCROLL_INSENSITIVE. It should return a
     * boolean value; either or false.
     */
    @Test
    public void testInsertsAreDetected2() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.insertsAreDetected(TYPE_SCROLL_INSENSITIVE)");
	    // invoke insertsAreDetected method
	    boolean retValue = dbmd
		    .insertsAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE);
	    if (retValue)
		logMsg("Visible row insert can be detected for TYPE_SCROLL_INSENSITIVE");
	    else
		logMsg("Visible row insert cannot be detected for TYPE_SCROLL_INSENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to insertsAreDetected2 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to insertsAreDetected2 is Failed!", e);
	}
    }

    /*
     * @testName: testInsertsAreDetected3
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The insertsAreDetected(int
     * resType) method must return a boolean value; true if the method
     * ResultSet.rowInserted returns true when called on a ResultSet object with
     * a given type that contains visible row insertion; false if the method
     * ResultSet.rowInserted returns false. The possible values for resType are
     * TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and TYPE_SCROLL_INSENSITIVE.(See
     * JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the insertsAreDetected() method on that object with the
     * result set type as ResultSet.TYPE_SCROLL_SENSITIVE. It should return a
     * boolean value; either or false.
     */
    @Test
    public void testInsertsAreDetected3() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.insertsAreDetected(TYPE_SCROLL_SENSITIVE)");
	    // invoke insertsAreDetected method
	    boolean retValue = dbmd
		    .insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE);
	    if (retValue)
		logMsg("Visible row insert can be detected for TYPE_SCROLL_SENSITIVE");
	    else
		logMsg("Visible row insert cannot be detected for TYPE_SCROLL_SENSITIVE");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to insertsAreDetected3 is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to insertsAreDetected3 is Failed!", e);
	}
    }

    /*
     * @testName: testGetUDTs
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The getUDTs() method must
     * return a ResultSet object with each row is a description of a UDT (User
     * Defined Type). (See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the getUDTs() method on that object. It should return a
     * ResultSet object. Validate the column names and column ordering.
     */
    @Test
    public void testGetUDTs() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.getUDTs");
	    // invoke getUDTs method
//	    ResultSet oRet_ResultSet = dbmd.getUDTs(sCatalogName, sSchemaName,
//		    "%", null);
	    ResultSet oRet_ResultSet = dbmd.getUDTs(null, null,
		    "%", null);
	    String sRetStr = new String();
	    sRetStr = "";
	    // Store all the type names returned
	    while (oRet_ResultSet.next())
		sRetStr += oRet_ResultSet.getString(3) + ",";
	    if (sRetStr == "")
		logMsg("getUDTs did not return any user defined types");
	    else
		logMsg("The type names returned Are : "
			+ sRetStr.substring(0, sRetStr.length() - 1));
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to getUDTs is Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to getUDTs Failed!", e);
	}
    }

    /*
     * @testName: testGetUDTs01
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The getUDTs() method must
     * return a ResultSet object with each row is a description of a UDT (User
     * Defined Type). (See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the getUDTs() method on that object. It should return a
     * ResultSet object. Validate the column names and column ordering.
     */
    @Test
    public void testGetUDTs01() throws Exception
    {
	try
	{
	    ResultSetMetaData rsmd = null;
	    String sColumnNames[] = { "TYPE_CAT", "TYPE_SCHEM", "TYPE_NAME",
		    "CLASS_NAME", "DATA_TYPE", "REMARKS" };
	    boolean statusColumnMatch = true;
	    boolean statusColumnCount = true;

	    String sRetStr = new String();
	    sRetStr = "";

	    int iColumnNamesLength = sColumnNames.length;
	    logMsg("Calling DatabaseMetaData.getUDTs");

	    // invoke getUDTs method
//	    ResultSet oRet_ResultSet = dbmd.getUDTs(sCatalogName, sSchemaName,
//		    "%", null);
	    ResultSet oRet_ResultSet = dbmd.getUDTs(null, null,
		    "%", null);
	    rsmd = oRet_ResultSet.getMetaData();

	    int iCount = rsmd.getColumnCount();

	    logMsg("Minimum Column Count is:" + iColumnNamesLength);

	    // Comparing Column Lengths
	    if (iColumnNamesLength > iCount)
		statusColumnCount = false;
	    else
		if (iColumnNamesLength < iCount)
		{
		    iCount = iColumnNamesLength;
		    statusColumnCount = true;
		}
		else
		    statusColumnCount = true;

	    logMsg("Comparing Column Names...");

	    while (iColumnNamesLength > 0)
	    {
		if (sColumnNames[iColumnNamesLength - 1].equalsIgnoreCase(rsmd
			.getColumnName(iCount)))
		{
		    statusColumnMatch = true;
		}
		else
		{
		    statusColumnMatch = false;
		    break;
		}
		iCount--;
		iColumnNamesLength--;
	    }

	    if ((statusColumnMatch == false) && (statusColumnCount == true))
	    {
		logMsg("Column names or order wrong.");
		throw new Exception("Call to getUDTs Failed!");
	    }

	    // Store all the type names returned
	    while (oRet_ResultSet.next())
		sRetStr += oRet_ResultSet.getString(3) + ",";
	    if (sRetStr == "")
		logMsg("getUDTs did not return any user defined types");
	    else
		logMsg("The type names returned Are : "
			+ sRetStr.substring(0, sRetStr.length() - 1));
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception("Call to getUDTs Failed!", sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception("Call to getUDTs Failed!", e);
	}
    }

    /*
     * @testName: testSupportsTransactionIsolationLevel1
     * 
     * @assertion: The DatabaseMetaData provides information about the database.
     * (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
     * 
     * A driver must provide full support for DatabaseMetaData and
     * ResultSetMetaData. This implies that all of the methods in the
     * DatabaseMetaData interface must be implemented and must behave as
     * specified in the JDBC 1.0 and 2.0 specifications. None of the methods in
     * DatabaseMetaData and ResultSetMetaData may throw an exception because
     * they are not implemented. (See section 6.2.2.3 of Java2 Platform
     * Enterprise Edition (J2EE) Specification v1.2) The
     * supportsTransactionIsolationLevel(int isolevel) method must return a
     * boolean value; true if the database supports the given Transaction
     * Isolation Level isolevel and false otherwise. The possible values for
     * isolevel can be TRANSACTION_NONE, TRANSACTION_READ_COMMITTED,
     * TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ and
     * TRANSACTION_SERIALIZABLE. (See JDK 1.2.2 API documentation)
     * 
     * @test_Strategy: Get a DatabaseMetadata object from the connection to the
     * database and call the supportsTransactionIsolationLevel(int isolevel)
     * method on that object with the isolation level TRANSACTION_NONE. It
     * should return a boolean value; either true or false.
     */
    @Test
    public void testSupportsTransactionIsolationLevel1() throws Exception
    {
	try
	{
	    logMsg("Calling DatabaseMetaData.supportsTransactionIsolationLevel(TRANSACTION_NONE)");
	    // invoke supportsTransactionIsolationLevel method
	    boolean retValue = dbmd
		    .supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE);
	    if (retValue)
		logMsg("supportsTransactionIsolationLevel(TRANSACTION_NONE) is supported");
	    else
		logMsg("supportsTransactionIsolationLevel(TRANSACTION_NONE) is not supported");
	}
	catch (SQLException sqle)
	{
	    logErr("SQL Exception " + sqle.getMessage());
	    throw new Exception(
		    "Call to supportsTransactionIsolationLevel1 is Failed!",
		    sqle);
	}
	catch (Exception e)
	{
	    logErr("Unexpected Exception " + e.getMessage());
	    throw new Exception(
		    "Call to supportsTransactionIsolationLevel1 is Failed!", e);
	}
    }

    /* cleanup */
    @AfterClass
    public static void cleanup() throws Exception
    {
	try
	{
	    // Close the database
//	    dbSch.destroyData(conn);
	    dbSch.dbUnConnect(conn);
	    logMsg("Cleanup ok;");
	}
	catch (Exception e)
	{
	    logErr("An error occurred while closing the database connection");
	}
    }
}
